// pages/biz/pay.js
const auth = require('../../utils/auth.js')
const bizPayService = require('../../services/bizPay.js')
const bizService = require('../../services/biz.js')
const cardService = require('../../services/card.js')

Page({

    /**
     * 页面的初始数据
     */
    data: {
        isLoggedIn: false,
        userInfo: null,
        loginReady: false,

        // 商家信息
        bizInfo: null,

        // 云豆相关
        userScore: 0,
        phone: '',

        // 卡片相关
        cardList: [],
        cardListWithStatus: [], // 带选中状态的卡片列表
        selectedCards: [], // 改为数组，支持多选
        useCardScore: 0,

        // 支付相关
        bizId: '',
        payRecordTradeNo: '',
        payPrice: '', // 原始支付金额
        payMoney: '', // 折扣后的实际支付金额
        originalPayMoney: '', // 原始支付金额（用于显示）
        useScore: 0,
        remainMoney: 0,
        discount: 0, // 折扣比例，如70表示70%
        discount_txt: '', // 折扣文本
        hasDiscount: false, // 是否有折扣
        syncIsVip: false, // 是否是VIP

        // 支付状态
        payRecordId: '',
        payStatus: 0, // 0=未支付，1=已支付
        paymentCompleted: false, // 支付是否已完成

        // UI状态
        loading: false,
        showPayPanel: false,
        showResultPanel: false,
        wxPayConfig: null, // 微信支付配置

        keyboardHeight: 0,

        discountInfoVisible:false,

        // 支付密码相关
        needPayPassword: false,
        payPassword: '',
        passwordArray: ['', '', '', '', '', ''],
        passwordInputFocus: false,
        showPasswordModal: false
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {



        // 获取商家ID
        if (options.biz_id) {
            this.setData({
                bizId: options.biz_id
            })

            // 获取商家基本信息
            this.loadBizInfo(options.biz_id)
        }

        wx.onKeyboardHeightChange(res => {
            this.setData({
                keyboardHeight: res.height + 50
            });
        });

        // 获取支付金额
        if (options.pay_price) {
            const originalPayMoney = parseFloat(options.pay_price)
            this.setData({
                payPrice: originalPayMoney.toString(), // 保持为字符串，支持用户编辑
                originalPayMoney: originalPayMoney,
                payMoney: originalPayMoney // 初始时等于原始金额，等折扣信息加载后再计算
            })
        }

        // 检查登录状态
        this.checkLoginStatus()
    },

    /**
     * 滚动到目标位置
     */
    scrollToTarget() {
        // 使用 wx.createSelectorQuery 获取页面高度
        const query = wx.createSelectorQuery()
        query.select('.pay-container').boundingClientRect()
        query.exec((res) => {
            if (res[0]) {
                const containerHeight = res[0].height

                // 如果内容高度足够，则执行滚动
                if (containerHeight > 500) {
                    wx.pageScrollTo({
                        scrollTop: this.data.keyboardHeight,
                        duration: 300
                    })
                }
            }
        })
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {
    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
        if (this.data.loginReady) {
            this.checkLoginStatus()
        }
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {

    },

    inputFocus(e) {
        this.scrollToTarget()
    },

    /**
     * 检查登录状态
     */
    async checkLoginStatus() {
        try {
            const loginStatus = await auth.checkLoginStatus()


            // 如果未登录或未绑定手机号，直接跳转到登录页面
            if (!loginStatus.isLoggedIn || !auth.isValidUserInfo(loginStatus.userInfo)) {
                wx.navigateTo({
                    url: '/pages/index/login'
                })
                return
            }

            this.setData({
                isLoggedIn: loginStatus.isLoggedIn,
                userInfo: loginStatus.userInfo,
                loginReady: true
            })

            // 获取云豆余额
            this.loadUserBalance()
        } catch (error) {

            // 检查失败时也跳转到登录页面
            wx.navigateTo({
                url: '/pages/index/login'
            })
        }
    },

    /**
     * 加载用户云豆余额
     */
    async loadUserBalance() {
        try {
            const result = await bizPayService.getBalance({
                biz_id: this.data.bizId
            })

            if (result.success) {
                const discount = result.data.discount
                const hasDiscount = discount && discount > 0 && discount < 100

                // 计算折扣后的实际支付金额
                let actualPayMoney = this.data.originalPayMoney || parseFloat(this.data.payPrice) || 0
                if (hasDiscount) {
                    actualPayMoney = (actualPayMoney * discount / 100).toFixed(2)
                }

                this.setData({
                    userScore: result.data.score,
                    phone: result.data.phone,
                    discount: discount,
                    discount_txt: result.data.discount_txt,
                    hasDiscount: hasDiscount,
                    payMoney: parseFloat(actualPayMoney),
                    syncIsVip: result.data.is_vip
                })

                // 加载用户卡片列表
                this.loadUserCards()

                // 计算支付方案
                this.calculatePayPlan()
            } else {
                wx.showToast({
                    title: result.message,
                    icon: 'none'
                })
            }
        } catch (error) {

            wx.showToast({
                title: '获取云豆余额失败',
                icon: 'none'
            })
        }
    },

    /**
     * 加载用户有效卡片列表（未过期且积分大于0）
     */
    async loadUserCards() {
        try {
            const result = await cardService.getValidCards({
                showLoading: false
            })

            if (result.success) {
                // 直接使用后端返回的有效卡片列表
                const validCards = result.data.list || []

                // 初始化带选中状态的卡片列表
                const cardListWithStatus = validCards.map(card => ({
                    ...card,
                    isSelected: false
                }))

                this.setData({
                    cardList: validCards,
                    cardListWithStatus: cardListWithStatus
                })


            } else {

            }
        } catch (error) {

        }
    },

    /**
     * 选择/取消选择卡片
     */
    onCardSelect(e) {
        const cardId = e.currentTarget.dataset.id
        const card = this.data.cardList.find(item => item.id == cardId)

        if (card) {
            const selectedCards = [...this.data.selectedCards]
            const existingIndex = selectedCards.findIndex(item => item.id == cardId)

            if (existingIndex > -1) {
                // 如果已选中，则取消选择
                selectedCards.splice(existingIndex, 1)
            } else {
                // 如果未选中，检查是否可以添加新卡片
                // 计算当前已选择卡片的云豆总量
                let currentTotalCardScore = 0
                for (const selectedCard of selectedCards) {
                    const cardScore = selectedCard.card_score || selectedCard.score || 0
                    currentTotalCardScore += cardScore
                }

                // 如果当前已选择的卡片云豆已经足够支付，则不允许再选择其他卡片
                const payMoneyNum = parseFloat(this.data.payMoney) || 0
                if (payMoneyNum == 0 && selectedCards.length > 0) {
                    if(selectedCards.length == 1){
                        selectedCards.pop()
                    }else{
                      wx.showToast({
                        title: '请先输入支付金额',
                        icon: 'none',
                        duration: 2000
                      })
                      return
                    }
                    
                }

                if (payMoneyNum > 0 && currentTotalCardScore >= payMoneyNum) {
                    if(selectedCards.length == 1){
                        selectedCards.pop()
                    }else{
                        wx.showToast({
                            title: '已选择的卡片云豆足够支付',
                            icon: 'none',
                            duration: 2000
                        })
                        return
                    }
                    
                }

                // 可以添加新卡片
                selectedCards.push(card)
            }

            // 更新卡片列表的选中状态
            const cardListWithStatus = this.data.cardListWithStatus.map(item => ({
                ...item,
                isSelected: selectedCards.some(selectedCard => selectedCard.id === item.id)
            }))

            this.setData({
                selectedCards: selectedCards,
                cardListWithStatus: cardListWithStatus,
                paymentCompleted: false // 重置支付完成状态
            })

            // 重新计算支付方案
            this.calculatePayPlan()
        }
    },

    /**
     * 取消选择所有卡片
     */
    onCardDeselect() {
        // 更新卡片列表的选中状态
        const cardListWithStatus = this.data.cardListWithStatus.map(item => ({
            ...item,
            isSelected: false
        }))

        this.setData({
            selectedCards: [],
            useCardScore: 0,
            cardListWithStatus: cardListWithStatus,
            paymentCompleted: false // 重置支付完成状态
        })

        // 重新计算支付方案
        this.calculatePayPlan()
    },

    /**
     * 格式化云豆数量显示
     */
    formatScore(score) {
        return parseFloat(score).toFixed(2)
    },

    /**
     * 计算支付方案
     */
    calculatePayPlan() {
        const { payMoney, userScore, selectedCards } = this.data

        // 确保 payMoney 是数字类型
        const payMoneyNum = parseFloat(payMoney) || 0
        if (payMoneyNum <= 0) return

        let totalUseScore = 0
        let totalCardScore = 0
        let useScore = 0

        // 1. 先计算用户选择的卡片云豆使用量（多选）
        if (selectedCards.length > 0) {
            let remainingPayMoney = payMoneyNum

            // 按卡片过期时间从近到远排序，优先使用即将过期的卡片
            const sortedCards = [...selectedCards].sort((a, b) => {
                const expiredAtA = a.expired_at || Number.MAX_SAFE_INTEGER
                const expiredAtB = b.expired_at || Number.MAX_SAFE_INTEGER
                return expiredAtA - expiredAtB
            })

            for (const card of sortedCards) {
                const cardScore = card.card_score || card.score || 0
                if (cardScore > 0 && remainingPayMoney > 0) {
                    const useCardScore = Math.min(cardScore, remainingPayMoney) // 支持小数
                    totalCardScore += useCardScore
                    totalUseScore += useCardScore
                    remainingPayMoney -= useCardScore
                }
            }
        }

        // 2. 然后自动计算云豆使用量（补足剩余金额）
        const remainingMoney = payMoneyNum - totalUseScore
        if (remainingMoney > 0) {
            const needScore = remainingMoney // 每个云豆代表1元，支持小数
            useScore = Math.min(userScore, needScore) // 使用的云豆数量
            totalUseScore += useScore
        }

        // 3. 最后计算微信支付补差价
        const remainMoney = (payMoneyNum - totalUseScore).toFixed(2) // 需要微信支付的金额

        // 4. 计算每个卡片的选中状态和实际使用云豆数量
        const cardListWithStatus = this.data.cardList.map(card => {
            const isSelected = selectedCards.some(selectedCard => selectedCard.id === card.id)
            let actualUseScore = 0

            if (isSelected) {
                // 重新计算该卡片实际使用的云豆数量
                const cardScore = card.card_score || card.score || 0
                let remainingPayMoney = payMoneyNum
                let usedCardScore = 0

                // 按卡片过期时间从近到远排序，优先使用即将过期的卡片
                const sortedSelectedCards = [...selectedCards].sort((a, b) => {
                    const expiredAtA = a.expired_at || Number.MAX_SAFE_INTEGER
                    const expiredAtB = b.expired_at || Number.MAX_SAFE_INTEGER
                    return expiredAtA - expiredAtB
                })

                // 计算到当前卡片为止的使用量
                for (const selectedCard of sortedSelectedCards) {
                    if (selectedCard.id === card.id) {
                        // 找到当前卡片，计算其实际使用量
                        if (cardScore > 0 && remainingPayMoney > 0) {
                            actualUseScore = Math.min(cardScore, remainingPayMoney)
                        }
                        break
                    } else {
                        // 其他卡片的使用量
                        const otherCardScore = selectedCard.card_score || selectedCard.score || 0
                        if (otherCardScore > 0 && remainingPayMoney > 0) {
                            const useOtherCardScore = Math.min(otherCardScore, remainingPayMoney)
                            usedCardScore += useOtherCardScore
                            remainingPayMoney -= useOtherCardScore
                        }
                    }
                }
            }

            return {
                ...card,
                isSelected: isSelected,
                actualUseScore: actualUseScore
            }
        })

        // 判断是否需要支付密码（卡云豆+余额云豆支付超过200）
        const totalCloudScore = totalUseScore
        
        const needPayPassword = (totalCloudScore <= 200 && this.data.userInfo.un_input_pay_password) ? false : true

        this.setData({
            useScore: parseFloat(useScore).toFixed(2),
            useCardScore: parseFloat(totalCardScore).toFixed(2),
            remainMoney: parseFloat(remainMoney).toFixed(2),
            cardListWithStatus: cardListWithStatus,
            needPayPassword: needPayPassword
        })


    },

    /**
     * 支付金额输入
     */
    onPayPriceInput(e) {
        const inputValue = e.detail.value

        // 保存原始输入值，允许用户输入中间状态（如 "1."）
        this.setData({
            payPrice: inputValue
        })

        // 只有在输入完成且有效时才解析和计算
        if (inputValue && !isNaN(parseFloat(inputValue))) {
            let payPrice = parseFloat(inputValue)
            let originalPayMoney = payPrice

            // 应用折扣计算实际支付金额
            let actualPayMoney = payPrice
            if (this.data.hasDiscount && this.data.discount > 0) {
                actualPayMoney = (payPrice * this.data.discount / 100).toFixed(2)
            }

            this.setData({
                originalPayMoney: originalPayMoney,
                payMoney: parseFloat(actualPayMoney),
                paymentCompleted: false // 重置支付完成状态
            })

            // 重新计算支付方案
            this.calculatePayPlan()
        } else {
            // 输入无效时，清空相关金额
            this.setData({
                originalPayMoney: 0,
                payMoney: 0,
                paymentCompleted: false
            })
        }
    },

    /**
     * 预览支付信息
     */
    prePay() {
        // 检查支付金额
        const payMoneyNum = parseFloat(this.data.payMoney) || 0
        if (payMoneyNum <= 0) {
            wx.showToast({
                title: '请输入有效的支付金额',
                icon: 'none'
            })
            return
        }

        // 检查商家ID
        if (!this.data.bizId) {
            wx.showToast({
                title: '商家信息错误',
                icon: 'none'
            })
            return
        }

        // 重新计算支付方案，确保数据最新
        this.calculatePayPlan()

        // 显示支付预览面板
        this.setData({
            showPayPanel: true
        })
    },

    /**
     * 开始支付
     */
    async startPay() {
        // 检查支付金额
        const payMoneyNum = parseFloat(this.data.payMoney) || 0
        if (payMoneyNum <= 0) {
            wx.showToast({
                title: '请输入有效的支付金额',
                icon: 'none'
            })
            return
        }

        // 检查商家ID
        if (!this.data.bizId) {
            wx.showToast({
                title: '商家信息错误',
                icon: 'none'
            })
            return
        }



        // 如果正在加载中，不允许重复点击
        if (this.data.loading) {
            return
        }

        this.setData({ loading: true })

        try {
            // 准备支付数据，分开提交云豆余额和福利卡数据
            const payData = {
                biz_id: this.data.bizId,
                pay_price: this.data.originalPayMoney, // 原始支付金额
                pay_money: this.data.payMoney, // 折扣后的实际支付金额
                discount: this.data.discount, // 折扣比例
                // 云豆余额相关数据
                use_score: this.data.useScore,
                // 福利卡相关数据
                use_card_score: this.data.useCardScore,
                selected_cards: this.data.selectedCards.map(card => {
                    // 从cardListWithStatus中获取该卡片的实际使用云豆数量
                    const cardWithStatus = this.data.cardListWithStatus.find(item => item.id == card.id)
                    const actualUseScore = cardWithStatus ? cardWithStatus.actualUseScore : 0

                    return {
                        card_id: card.id,
                        card_name: card.card_name || card.name || '',
                        card_score: card.card_score || card.score || 0,
                        use_score: actualUseScore
                    }
                }),

                // 密码
                pay_password: this.data.payPassword
            }


            const result = await bizPayService.createPay(payData)


            if (result.success) {
                const payData = result.data

                this.setData({
                    payRecordTradeNo: payData.pay_trade_no,
                    payRecordId: payData.pay_record_id,
                    payStatus: payData.pay_status,
                    useScore: payData.use_score || this.data.useScore,
                    useCardScore: payData.use_card_score || this.data.useCardScore,
                    remainMoney: payData.remain_money || this.data.remainMoney
                })

                // 判断是否需要微信支付
                const needWxPay = (payData.remain_money || this.data.remainMoney) > 0

                if (payData.pay_status === 1) {
                    // 支付成功（云豆+卡片云豆支付完成）
                    const payMessage = this.getPaySuccessMessage()
                    this.setData({
                        paymentCompleted: true
                    })
                    this.showPayResult(true, payMessage)
                    
                    // 重置支付密码状态
                    this.resetPayPassword()
                } else if (payData.remain_money > 0) {
                    // 需要微信支付补差价
                    if (payData.wx_pay_config) {
                        // 如果有微信支付配置，直接调用微信支付
                        this.doWxPayment(payData.wx_pay_config)
                    } else {
                        // 如果没有配置，显示错误提示
                        wx.showToast({
                            title: '微信支付配置获取失败',
                            icon: 'none'
                        })
                    }
                } else if (payData.remain_money <= 0) {
                    // 补差价不大于0，支付完成
                    const payMessage = this.getPaySuccessMessage()
                    this.setData({
                        paymentCompleted: true
                    })
                    this.showPayResult(true, payMessage)
                    
                    // 重置支付密码状态
                    this.resetPayPassword()
                } else {
                    // 其他情况，也显示支付成功
                    const payMessage = this.getPaySuccessMessage()
                    this.setData({
                        paymentCompleted: true
                    })
                    this.showPayResult(true, payMessage)
                }
            } else {
                wx.showToast({
                    title: result.message,
                    icon: 'none'
                })
            }
        } catch (error) {

            wx.showToast({
                title: '支付失败，请重试',
                icon: 'none'
            })
        } finally {
            this.setData({ loading: false })
        }
    },

    /**
     * 获取支付成功消息
     */
    getPaySuccessMessage() {
        const { useScore, useCardScore, payMoney, remainMoney, hasDiscount, discount, originalPayMoney } = this.data
        let message = '支付成功'

        if (useScore > 0 && useCardScore > 0) {
            message = `福利卡和云豆支付成功，共支付¥${payMoney}`
        } else if (useCardScore > 0) {
            message = `福利卡支付成功，共支付¥${payMoney}`
        } else if (useScore > 0) {
            message = `云豆支付成功，共支付¥${payMoney}`
        } else {
            message = `支付成功，共支付¥${payMoney}`
        }

        // 如果有折扣，在消息中说明
        if (hasDiscount && discount > 0) {
            message += `（享受${discount}%折扣，原价¥${originalPayMoney}）`
        }

        // 如果有微信支付部分，在消息中说明
        if (remainMoney > 0) {
            message += `（含微信支付¥${remainMoney}）`
        } else {
            message += `（无需微信支付）`
        }

        return message
    },

    /**
     * 显示支付面板
     */
    showPayPanel(wxPayConfig) {
        // 确保在显示支付面板时重新计算一次金额
        this.calculatePayPlan()

        

        this.setData({
            showPayPanel: true,
            wxPayConfig: wxPayConfig
        })
    },

    /**
     * 执行微信支付
     */
    async doWxPay() {
        // 先关闭预览面板
        this.setData({
            showPayPanel: false
        })

        // 检查是否需要支付密码
        if (this.data.needPayPassword) {
            // 显示支付密码对话框
            this.setData({
                showPasswordModal: true,
                payPassword: '',
                passwordArray: ['', '', '', '', '', ''],
                passwordInputFocus: false
            })
            return
        }

        // 调用真实的支付请求
        await this.startPay()
    },

    /**
     * 执行真实的微信支付
     */
    async doWxPayment(wxPayConfig) {
        if (!wxPayConfig) {
            wx.showToast({
                title: '支付配置错误',
                icon: 'none'
            })
            return
        }

        try {
            wx.requestPayment({
                timeStamp: wxPayConfig.timeStamp,
                nonceStr: wxPayConfig.nonceStr,
                package: wxPayConfig.package,
                signType: wxPayConfig.signType,
                paySign: wxPayConfig.paySign,
                success: (res) => {
                    if (res.errMsg === 'requestPayment:ok') {
                        // 支付成功，查询支付状态
                        this.checkPayStatus()
                    } else {
                        wx.showToast({
                            title: '支付失败',
                            icon: 'none'
                        })
                    }
                },
                fail: (res) => {

                    wx.showToast({
                        title: '支付失败',
                        icon: 'none'
                    })
                }
            })
        } catch (error) {

            wx.showToast({
                title: '支付异常',
                icon: 'none'
            })
        }
    },

    goPayScan() {
        wx.scanCode({
            onlyFromCamera: true,
            scanType: ['qrCode'],
            success: (res) => {

            }
        })
    },

    /**
     * 检查支付状态
     */
    async checkPayStatus() {
        if (!this.data.payRecordId) return

        try {
            const result = await bizPayService.queryPayStatus(this.data.payRecordId)

            if (result.success) {
                const payData = result.data

                this.setData({
                    payStatus: payData.pay_statu
                })

                if (payData.pay_status === 1) {
                    this.showPayResult(true, '支付成功')
                } else {
                    // 继续轮询支付状态
                    setTimeout(() => {
                        this.checkPayStatus()
                    }, 2000)
                }
            }
        } catch (error) {

        }
    },

    /**
     * 显示支付结果
     */
    showPayResult(success, message) {
        // 获取当前时间作为支付时间
        const now = new Date()
        const payTime = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`
        
        // 构建支付方式描述
        let payMethod = ''
        if (this.data.useCardScore > 0 && this.data.useScore > 0 && this.data.remainMoney > 0) {
            payMethod = '福利卡+云豆+微信支付'
        } else if (this.data.useCardScore > 0 && this.data.useScore > 0) {
            payMethod = '福利卡+云豆'
        } else if (this.data.useCardScore > 0 && this.data.remainMoney > 0) {
            payMethod = '福利卡+微信支付'
        } else if (this.data.useScore > 0 && this.data.remainMoney > 0) {
            payMethod = '云豆+微信支付'
        } else if (this.data.useCardScore > 0) {
            payMethod = '福利卡'
        } else if (this.data.useScore > 0) {
            payMethod = '云豆'
        } else if (this.data.remainMoney > 0) {
            payMethod = '微信支付'
        }

        this.setData({
            showPayPanel: false,
            showResultPanel: true,
            payResult: {
                success: success,
                message: message,
                orderNo: this.data.payRecordTradeNo || 'N/A',
                discount: this.data.hasDiscount ? `${this.data.discount}%` : '无',
                originalAmount: this.data.originalPayMoney || this.data.payPrice,
                actualAmount: this.data.payMoney,
                payMethod: payMethod,
                payTime: payTime
            }
        })
    },

    /**
     * 关闭支付面板
     */
    closePayPanel() {
        this.setData({
            showPayPanel: false
        })
        
        // 重置支付密码状态
        this.resetPayPassword()
    },

    /**
     * 关闭结果面板
     */
    closeResultPanel() {
        this.setData({
            showResultPanel: false
        })

        // 返回上一页
        wx.navigateBack()
    },



    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {
        this.loadUserBalance().finally(() => {
            wx.stopPullDownRefresh()
        })
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {
        return {
            title: '云豆支付',
            path: '/pages/biz/pay'
        }
    },

    /**
     * 加载商家基本信息
     */
    async loadBizInfo(bizId) {
        try {
            const result = await bizService.getBizDetail({
                id: bizId,
                showLoading: true
            })

            if (result.success) {
                this.setData({
                    bizInfo: result.data
                })

            } else {
                wx.showToast({
                    title: result.message || '获取商家信息失败',
                    icon: 'none'
                })
            }
        } catch (error) {

            wx.showToast({
                title: '获取商家信息失败',
                icon: 'none'
            })
        }
    },

    /**
     * 手动触发滚动（可在需要时调用）
     */
    manualScroll() {

        this.scrollToTarget()
    },

    /**
     * 滚动到指定元素
     */
    scrollToElement(selector) {
        const query = wx.createSelectorQuery()
        query.select(selector).boundingClientRect()
        query.exec((res) => {
            if (res[0]) {
                const top = res[0].top
                wx.pageScrollTo({
                    scrollTop: top - 100, // 减去100px的偏移量
                    duration: 300
                })
            }
        })
    },

    showDiscountInfo() {
        this.setData({
            discountInfoVisible: true
        })
    },

    /**
     * 关闭折扣信息面板
     */
    closeDiscountInfo() {
        this.setData({
            discountInfoVisible: false
        })
    },

    toVip() {
        wx.switchTab({
            url: '/pages/index/vip'
        })
    },

    /**
     * 聚焦支付密码输入框
     */
    focusPasswordInput() {
        this.setData({
            passwordInputFocus: true
        })
    },

    /**
     * 支付密码输入处理
     */
    onPasswordInput(e) {
        const value = e.detail.value
        const passwordArray = value.split('').concat(Array(6 - value.length).fill(''))
        
        this.setData({
            payPassword: value,
            passwordArray: passwordArray
        })
    },

    /**
     * 重置支付密码状态
     */
    resetPayPassword() {
        this.setData({
            payPassword: '',
            passwordArray: ['', '', '', '', '', ''],
            passwordInputFocus: false
        })
    },

    /**
     * 验证支付密码
     */
    async verifyPayPassword(password) {
        try {
            // TODO: 需要后端实现验证支付密码的API
            // 建议的API路径: POST /v1/user/verifyPayPassword
            // 参数: { pay_password: password }
            // 返回: { success: true/false, message: '验证结果' }
            
            // 临时实现：模拟验证过程
            // 实际项目中应该调用后端API
            console.log('验证支付密码:', password)
            
            // 这里可以添加临时的验证逻辑，比如检查密码格式等
            if (password && password.length === 6 && /^\d{6}$/.test(password)) {
                // 密码格式正确，实际应该调用后端验证
                return true
            }
            
            return false
        } catch (error) {
            console.error('验证支付密码失败:', error)
            return false
        }
    },

    /**
     * 关闭支付密码对话框
     */
    closePasswordModal() {
        this.setData({
            showPasswordModal: false,
            payPassword: '',
            passwordArray: ['', '', '', '', '', ''],
            passwordInputFocus: false
        })
    },

    /**
     * 确认支付密码
     */
    async confirmPassword() {
        if (this.data.payPassword.length !== 6) {
            wx.showToast({
                title: '请输入6位支付密码',
                icon: 'none'
            })
            return
        }

        // 验证支付密码
        const passwordValid = await this.verifyPayPassword(this.data.payPassword)
        if (!passwordValid) {
            wx.showToast({
                title: '支付密码错误',
                icon: 'none'
            })
            return
        }

        // 密码验证成功，关闭对话框并继续支付
        this.setData({
            showPasswordModal: false
        })

        // 调用真实的支付请求
        await this.startPay()
    }
})